package com.caipiao.lottery.abc;

public class BubbleSort {

    /**
     * 冒泡排序算法实现
     * @param arr 待排序的数组
     */
    public static void bubbleSort(int[] arr) {
        // 处理空数组或长度为1的数组
        if (arr == null || arr.length <= 1) {
            return;
        }

        int n = arr.length;
        // 外层循环控制排序轮数
        for (int i = 0; i < n - 1; i++) {
            // 标记本轮是否发生交换，优化排序效率
            boolean swapped = false;

            // 内层循环进行相邻元素比较和交换
            // 每轮结束后，最大元素已"冒泡"到末尾，故内层循环边界逐渐减小
            for (int j = 0; j < n - 1 - i; j++) {
                // 若当前元素大于后一个元素，则交换位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }

            // 若本轮未发生交换，说明数组已排序完成，提前退出
            if (!swapped) {
                break;
            }
        }
    }

    /**
     * 获取数组中的最大值
     * @param arr 待处理的数组
     * @return 数组中的最大值，若数组为空或为null则返回Integer.MIN_VALUE
     */
    public static int getMax(int[] arr) {
        if (arr == null || arr.length == 0) {
            return Integer.MIN_VALUE;
        }
        int max = arr[0];
        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }
        return max;
    }

    /**
     * 获取数组中的最小值
     * @param arr 待处理的数组
     * @return 数组中的最小值，若数组为空或为null则返回Integer.MAX_VALUE
     */
    public static int getMin(int[] arr) {
        if (arr == null || arr.length == 0) {
            return Integer.MAX_VALUE;
        }
        int min = arr[0];
        for (int num : arr) {
            if (num < min) {
                min = num;
            }
        }
        return min;
    }

    /**
     * 计算数组中元素的平均值
     * @param arr 待处理的数组
     * @return 数组元素的平均值，若数组为空或为null则返回0
     */
    public static double getAverage(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return (double) sum / arr.length;
    }

    /**
     * 对字符串数组进行排序
     * @param arr 待排序的字符串数组
     */
    public static void bubbleSortStrings(String[] arr) {
        if (arr == null || arr.length <= 1) {
            return;
        }
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j].compareTo(arr[j + 1]) > 0) {
                    String temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;
            }
        }
    }

    /**
     * 获取字符串数组中最长的字符串
     * @param arr 待处理的字符串数组
     * @return 最长的字符串，若数组为空或为null则返回null
     */
    public static String getLongestString(String[] arr) {
        if (arr == null || arr.length == 0) {
            return null;
        }
        String longest = arr[0];
        for (String str : arr) {
            if (str.length() > longest.length()) {
                longest = str;
            }
        }
        return longest;
    }

    /**
     * 获取字符串数组中最短的字符串
     * @param arr 待处理的字符串数组
     * @return 最短的字符串，若数组为空或为null则返回null
     */
    public static String getShortestString(String[] arr) {
        if (arr == null || arr.length == 0) {
            return null;
        }
        String shortest = arr[0];
        for (String str : arr) {
            if (str.length() < shortest.length()) {
                shortest = str;
            }
        }
        return shortest;
    }

    /**
     * 计算字符串数组中字符串的平均长度
     * @param arr 待处理的字符串数组
     * @return 字符串的平均长度，若数组为空或为null则返回0
     */
    public static double getAverageStringLength(String[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int totalLength = 0;
        for (String str : arr) {
            totalLength += str.length();
        }
        return (double) totalLength / arr.length;
    }

    // 示例用法
    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("排序前数组:");
        for (int num : array) {
            System.out.print(num + " ");
        }

        bubbleSort(array);

        System.out.println("\n排序后数组:");
        for (int num : array) {
            System.out.print(num + " ");
        }
        
        String[] stringArray = {"apple", "banana", "cherry", "date"};
        System.out.println("\n\n字符串数组排序前:");
        for (String str : stringArray) {
            System.out.print(str + " ");
        }

        bubbleSortStrings(stringArray);

        System.out.println("\n字符串数组排序后:");
        for (String str : stringArray) {
            System.out.print(str + " ");
        }

        System.out.println("\n最长的字符串: " + getLongestString(stringArray));
        System.out.println("最短的字符串: " + getShortestString(stringArray));
        System.out.println("字符串平均长度: " + getAverageStringLength(stringArray));
    }
}